//本文件由程序自动生成,请不要自行修改
using System;
using fastCSharp;

#if NotFastCSharpCode
#else
#pragma warning disable
namespace diantou.dataModel
{
        public partial class answer
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 问题标识
                /// </summary>
                public int QuestionId;
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return QuestionId/**/.Equals(other.QuestionId) && UserId/**/.Equals(other.UserId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return QuestionId.GetHashCode() ^ UserId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.answer
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.answer, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.answer, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class comment
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.comment
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.comment> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.comment>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class contest
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.contest
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contest> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contest>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.contest> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.contest>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.contest>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 7, 8, 14);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.contest> _m7 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.JudgeUserCount);
                    /// <summary>
                    /// 提交用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void JudgeUserCount(int value)
                    {
                        if (!value.Equals(_value_.JudgeUserCount))
                        {
                            _value_.JudgeUserCount = value;
                            JudgeUserCount();
                        }
                    }
                    /// <summary>
                    /// 提交用户数量 (更新日志流)
                    /// </summary>
                    public void JudgeUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m7);
                    }
                    /// <summary>
                    /// 提交用户数量 计算初始化完毕
                    /// </summary>
                    public static void JudgeUserCountLoaded() { sqlStreamCount/**/.Load(7); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.contest> _m8 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ProblemCount);
                    /// <summary>
                    /// 题目数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ProblemCount(int value)
                    {
                        if (!value.Equals(_value_.ProblemCount))
                        {
                            _value_.ProblemCount = value;
                            ProblemCount();
                        }
                    }
                    /// <summary>
                    /// 题目数量 (更新日志流)
                    /// </summary>
                    public void ProblemCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m8);
                    }
                    /// <summary>
                    /// 题目数量 计算初始化完毕
                    /// </summary>
                    public static void ProblemCountLoaded() { sqlStreamCount/**/.Load(8); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.contest> _m14 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UserCount);
                    /// <summary>
                    /// 注册用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UserCount(int value)
                    {
                        if (!value.Equals(_value_.UserCount))
                        {
                            _value_.UserCount = value;
                            UserCount();
                        }
                    }
                    /// <summary>
                    /// 注册用户数量 (更新日志流)
                    /// </summary>
                    public void UserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m14);
                    }
                    /// <summary>
                    /// 注册用户数量 计算初始化完毕
                    /// </summary>
                    public static void UserCountLoaded() { sqlStreamCount/**/.Load(14); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class contestOwner
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 比赛标识
                /// </summary>
                public int ContestId;
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ContestId/**/.Equals(other.ContestId) && UserId/**/.Equals(other.UserId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ContestId.GetHashCode() ^ UserId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.contestOwner
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contestOwner, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contestOwner, primaryKey>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.contestOwner> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.contestOwner>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.contestOwner>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class contestProblem
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 问题标识
                /// </summary>
                public int ProblemId;
                /// <summary>
                /// 比赛标识
                /// </summary>
                public int ContestId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ProblemId/**/.Equals(other.ProblemId) && ContestId/**/.Equals(other.ContestId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ProblemId.GetHashCode() ^ ContestId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.contestProblem
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contestProblem, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contestProblem, primaryKey>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.contestProblem> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.contestProblem>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.contestProblem>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class contestUser
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 比赛标识
                /// </summary>
                public int ContestId;
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ContestId/**/.Equals(other.ContestId) && UserId/**/.Equals(other.UserId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ContestId.GetHashCode() ^ UserId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.contestUser
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contestUser, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.contestUser, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class course
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.course
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.course> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.course>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class coursePage
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 课程标识
                /// </summary>
                public int CourseId;
                /// <summary>
                /// 排序标识
                /// </summary>
                public byte SortId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return CourseId/**/.Equals(other.CourseId) && SortId/**/.Equals(other.SortId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return CourseId.GetHashCode() ^ SortId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.coursePage
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.coursePage, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.coursePage, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class enterprise
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.enterprise
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterprise> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterprise>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.enterprise> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "ExamDataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.enterprise>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "ExamDataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.enterprise>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 0);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.enterprise> _m0 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.EnterpriseBalance);
                    /// <summary>
                    /// 企业账户余额(单位：分) (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void EnterpriseBalance(int value)
                    {
                        if (!value.Equals(_value_.EnterpriseBalance))
                        {
                            _value_.EnterpriseBalance = value;
                            EnterpriseBalance();
                        }
                    }
                    /// <summary>
                    /// 企业账户余额(单位：分) (更新日志流)
                    /// </summary>
                    public void EnterpriseBalance()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m0);
                    }
                    /// <summary>
                    /// 企业账户余额(单位：分) 计算初始化完毕
                    /// </summary>
                    public static void EnterpriseBalanceLoaded() { sqlStreamCount/**/.Load(0); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class enterpriseAccount
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 交易时间
                /// </summary>
                public System.DateTime Time;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && Time/**/.Equals(other.Time);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ Time/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.enterpriseAccount
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseAccount, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseAccount, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class enterpriseJob
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.enterpriseJob
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseJob> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseJob>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class enterpriseMail
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.enterpriseMail
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseMail> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseMail>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class enterpriseNotice
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.enterpriseNotice
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseNotice> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.enterpriseNotice>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class exam
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.exam
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.exam> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.exam>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.exam> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "ExamDataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.exam>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "ExamDataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.exam>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 0, 6, 12, 16, 17, 18, 20, 22, 23, 24, 25, 30);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m0 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.AnswerUserCount);
                    /// <summary>
                    /// 答题人数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void AnswerUserCount(int value)
                    {
                        if (!value.Equals(_value_.AnswerUserCount))
                        {
                            _value_.AnswerUserCount = value;
                            AnswerUserCount();
                        }
                    }
                    /// <summary>
                    /// 答题人数 (更新日志流)
                    /// </summary>
                    public void AnswerUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m0);
                    }
                    /// <summary>
                    /// 答题人数 计算初始化完毕
                    /// </summary>
                    public static void AnswerUserCountLoaded() { sqlStreamCount/**/.Load(0); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m6 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.InvitationCount);
                    /// <summary>
                    /// 邀请数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void InvitationCount(int value)
                    {
                        if (!value.Equals(_value_.InvitationCount))
                        {
                            _value_.InvitationCount = value;
                            InvitationCount();
                        }
                    }
                    /// <summary>
                    /// 邀请数量 (更新日志流)
                    /// </summary>
                    public void InvitationCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m6);
                    }
                    /// <summary>
                    /// 邀请数量 计算初始化完毕
                    /// </summary>
                    public static void InvitationCountLoaded() { sqlStreamCount/**/.Load(6); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m12 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.JobCount);
                    /// <summary>
                    /// 工作职位数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void JobCount(int value)
                    {
                        if (!value.Equals(_value_.JobCount))
                        {
                            _value_.JobCount = value;
                            JobCount();
                        }
                    }
                    /// <summary>
                    /// 工作职位数量 (更新日志流)
                    /// </summary>
                    public void JobCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m12);
                    }
                    /// <summary>
                    /// 工作职位数量 计算初始化完毕
                    /// </summary>
                    public static void JobCountLoaded() { sqlStreamCount/**/.Load(12); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m16 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.MultipleChoiceCount);
                    /// <summary>
                    /// 多选题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void MultipleChoiceCount(int value)
                    {
                        if (!value.Equals(_value_.MultipleChoiceCount))
                        {
                            _value_.MultipleChoiceCount = value;
                            MultipleChoiceCount();
                        }
                    }
                    /// <summary>
                    /// 多选题数量 (更新日志流)
                    /// </summary>
                    public void MultipleChoiceCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m16);
                    }
                    /// <summary>
                    /// 多选题数量 计算初始化完毕
                    /// </summary>
                    public static void MultipleChoiceCountLoaded() { sqlStreamCount/**/.Load(16); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m17 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.PaperCount);
                    /// <summary>
                    /// 已经结束考试的试卷数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void PaperCount(int value)
                    {
                        if (!value.Equals(_value_.PaperCount))
                        {
                            _value_.PaperCount = value;
                            PaperCount();
                        }
                    }
                    /// <summary>
                    /// 已经结束考试的试卷数量 (更新日志流)
                    /// </summary>
                    public void PaperCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m17);
                    }
                    /// <summary>
                    /// 已经结束考试的试卷数量 计算初始化完毕
                    /// </summary>
                    public static void PaperCountLoaded() { sqlStreamCount/**/.Load(17); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m18 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ProblemCount);
                    /// <summary>
                    /// 编程题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ProblemCount(int value)
                    {
                        if (!value.Equals(_value_.ProblemCount))
                        {
                            _value_.ProblemCount = value;
                            ProblemCount();
                        }
                    }
                    /// <summary>
                    /// 编程题数量 (更新日志流)
                    /// </summary>
                    public void ProblemCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m18);
                    }
                    /// <summary>
                    /// 编程题数量 计算初始化完毕
                    /// </summary>
                    public static void ProblemCountLoaded() { sqlStreamCount/**/.Load(18); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m20 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ProblemPoint);
                    /// <summary>
                    /// 编程题分数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ProblemPoint(int value)
                    {
                        if (!value.Equals(_value_.ProblemPoint))
                        {
                            _value_.ProblemPoint = value;
                            ProblemPoint();
                        }
                    }
                    /// <summary>
                    /// 编程题分数 (更新日志流)
                    /// </summary>
                    public void ProblemPoint()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m20);
                    }
                    /// <summary>
                    /// 编程题分数 计算初始化完毕
                    /// </summary>
                    public static void ProblemPointLoaded() { sqlStreamCount/**/.Load(20); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m22 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.QuestionCount);
                    /// <summary>
                    /// 问答题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void QuestionCount(int value)
                    {
                        if (!value.Equals(_value_.QuestionCount))
                        {
                            _value_.QuestionCount = value;
                            QuestionCount();
                        }
                    }
                    /// <summary>
                    /// 问答题数量 (更新日志流)
                    /// </summary>
                    public void QuestionCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m22);
                    }
                    /// <summary>
                    /// 问答题数量 计算初始化完毕
                    /// </summary>
                    public static void QuestionCountLoaded() { sqlStreamCount/**/.Load(22); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m23 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.QuestionPoint);
                    /// <summary>
                    /// 问答题分数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void QuestionPoint(int value)
                    {
                        if (!value.Equals(_value_.QuestionPoint))
                        {
                            _value_.QuestionPoint = value;
                            QuestionPoint();
                        }
                    }
                    /// <summary>
                    /// 问答题分数 (更新日志流)
                    /// </summary>
                    public void QuestionPoint()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m23);
                    }
                    /// <summary>
                    /// 问答题分数 计算初始化完毕
                    /// </summary>
                    public static void QuestionPointLoaded() { sqlStreamCount/**/.Load(23); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m24 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.RadioCount);
                    /// <summary>
                    /// 单选题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void RadioCount(int value)
                    {
                        if (!value.Equals(_value_.RadioCount))
                        {
                            _value_.RadioCount = value;
                            RadioCount();
                        }
                    }
                    /// <summary>
                    /// 单选题数量 (更新日志流)
                    /// </summary>
                    public void RadioCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m24);
                    }
                    /// <summary>
                    /// 单选题数量 计算初始化完毕
                    /// </summary>
                    public static void RadioCountLoaded() { sqlStreamCount/**/.Load(24); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m25 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.RegisterCount);
                    /// <summary>
                    /// 考试注册人数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void RegisterCount(int value)
                    {
                        if (!value.Equals(_value_.RegisterCount))
                        {
                            _value_.RegisterCount = value;
                            RegisterCount();
                        }
                    }
                    /// <summary>
                    /// 考试注册人数 (更新日志流)
                    /// </summary>
                    public void RegisterCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m25);
                    }
                    /// <summary>
                    /// 考试注册人数 计算初始化完毕
                    /// </summary>
                    public static void RegisterCountLoaded() { sqlStreamCount/**/.Load(25); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.exam> _m30 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UserCount);
                    /// <summary>
                    /// 考试人数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UserCount(int value)
                    {
                        if (!value.Equals(_value_.UserCount))
                        {
                            _value_.UserCount = value;
                            UserCount();
                        }
                    }
                    /// <summary>
                    /// 考试人数 (更新日志流)
                    /// </summary>
                    public void UserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m30);
                    }
                    /// <summary>
                    /// 考试人数 计算初始化完毕
                    /// </summary>
                    public static void UserCountLoaded() { sqlStreamCount/**/.Load(30); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class examAnswer
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 考试用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 考试问题标识
                /// </summary>
                public int QuestionId;
                /// <summary>
                /// 考试类型
                /// </summary>
                public diantou.dataModel.examQuestionBase.type Type;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && QuestionId/**/.Equals(other.QuestionId) && Type/**/.Equals(other.Type);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ QuestionId/**/.GetHashCode() ^ Type/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examAnswer
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examAnswer, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examAnswer, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examEnterpriseReviewer
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 企业用户标识
                /// </summary>
                public int EnterpriseId;
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return EnterpriseId/**/.Equals(other.EnterpriseId) && UserId/**/.Equals(other.UserId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return EnterpriseId.GetHashCode() ^ UserId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examEnterpriseReviewer
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examEnterpriseReviewer, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examEnterpriseReviewer, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examInvitation
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 考试标识
                /// </summary>
                public int ExamId;
                /// <summary>
                /// 邮箱/手机
                /// </summary>
                public string EmailMobile;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ExamId/**/.Equals(other.ExamId) && EmailMobile/**/.Equals(other.EmailMobile);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ExamId.GetHashCode() ^ EmailMobile/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examInvitation
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examInvitation, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examInvitation, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examItem
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 考试标识
                /// </summary>
                public int ExamId;
                /// <summary>
                /// 考试问题标识
                /// </summary>
                public int QuestionId;
                /// <summary>
                /// 考试类型
                /// </summary>
                public diantou.dataModel.examQuestionBase.type Type;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ExamId/**/.Equals(other.ExamId) && QuestionId/**/.Equals(other.QuestionId) && Type/**/.Equals(other.Type);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ExamId.GetHashCode() ^ QuestionId/**/.GetHashCode() ^ Type/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examItem
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examItem, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examItem, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examJob
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 考试标识
                /// </summary>
                public int ExamId;
                /// <summary>
                /// 工作职位标识
                /// </summary>
                public int JobId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ExamId/**/.Equals(other.ExamId) && JobId/**/.Equals(other.JobId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ExamId.GetHashCode() ^ JobId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examJob
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examJob, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examJob, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examJudgeLog
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examJudgeLog
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examJudgeLog> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examJudgeLog>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examLog
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examLog
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examLog> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examLog>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examProblem
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examProblem
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examProblem> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examProblem>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.examProblem> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "ExamDataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.examProblem>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "ExamDataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.examProblem>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 14, 15);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.examProblem> _m14 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.TopicCount);
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void TopicCount(int value)
                    {
                        if (!value.Equals(_value_.TopicCount))
                        {
                            _value_.TopicCount = value;
                            TopicCount();
                        }
                    }
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    public void TopicCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m14);
                    }
                    /// <summary>
                    /// 话题数量 计算初始化完毕
                    /// </summary>
                    public static void TopicCountLoaded() { sqlStreamCount/**/.Load(14); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.examProblem> _m15 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UsedCount);
                    /// <summary>
                    /// 选用数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UsedCount(int value)
                    {
                        if (!value.Equals(_value_.UsedCount))
                        {
                            _value_.UsedCount = value;
                            UsedCount();
                        }
                    }
                    /// <summary>
                    /// 选用数量 (更新日志流)
                    /// </summary>
                    public void UsedCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m15);
                    }
                    /// <summary>
                    /// 选用数量 计算初始化完毕
                    /// </summary>
                    public static void UsedCountLoaded() { sqlStreamCount/**/.Load(15); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class examQuestion
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examQuestion
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examQuestion> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examQuestion>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.examQuestion> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "ExamDataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.examQuestion>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "ExamDataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.examQuestion>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 16, 18);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.examQuestion> _m16 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.TopicCount);
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void TopicCount(int value)
                    {
                        if (!value.Equals(_value_.TopicCount))
                        {
                            _value_.TopicCount = value;
                            TopicCount();
                        }
                    }
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    public void TopicCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m16);
                    }
                    /// <summary>
                    /// 话题数量 计算初始化完毕
                    /// </summary>
                    public static void TopicCountLoaded() { sqlStreamCount/**/.Load(16); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.examQuestion> _m18 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UsedCount);
                    /// <summary>
                    /// 选用数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UsedCount(int value)
                    {
                        if (!value.Equals(_value_.UsedCount))
                        {
                            _value_.UsedCount = value;
                            UsedCount();
                        }
                    }
                    /// <summary>
                    /// 选用数量 (更新日志流)
                    /// </summary>
                    public void UsedCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m18);
                    }
                    /// <summary>
                    /// 选用数量 计算初始化完毕
                    /// </summary>
                    public static void UsedCountLoaded() { sqlStreamCount/**/.Load(18); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class examReviewer
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 考试标识
                /// </summary>
                public int ExamId;
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ExamId/**/.Equals(other.ExamId) && UserId/**/.Equals(other.UserId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ExamId.GetHashCode() ^ UserId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examReviewer
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examReviewer, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examReviewer, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class examUser
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 企业考试标识
                /// </summary>
                public int ExamId;
                /// <summary>
                /// 手机号
                /// </summary>
                public long Mobile;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ExamId/**/.Equals(other.ExamId) && Mobile/**/.Equals(other.Mobile);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ExamId.GetHashCode() ^ Mobile/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.examUser
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examUser, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.examUser, primaryKey>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.examUser> sqlStream;
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "ExamDataLog")]
                protected static void onSqlLog(Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.examUser>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 1, 26);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.examUser> _m1 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.CameraTime);
                    /// <summary>
                    /// 摄像头同步时间 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void CameraTime(System.DateTime value)
                    {
                        if (!value.Equals(_value_.CameraTime))
                        {
                            _value_.CameraTime = value;
                            CameraTime();
                        }
                    }
                    /// <summary>
                    /// 摄像头同步时间 (更新日志流)
                    /// </summary>
                    public void CameraTime()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m1);
                    }
                    /// <summary>
                    /// 摄像头同步时间 计算初始化完毕
                    /// </summary>
                    public static void CameraTimeLoaded() { sqlStreamCount/**/.Load(1); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.examUser> _m26 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.QuestionIndex);
                    /// <summary>
                    /// 当前考试题目编号 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void QuestionIndex(int value)
                    {
                        if (!value.Equals(_value_.QuestionIndex))
                        {
                            _value_.QuestionIndex = value;
                            QuestionIndex();
                        }
                    }
                    /// <summary>
                    /// 当前考试题目编号 (更新日志流)
                    /// </summary>
                    public void QuestionIndex()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m26);
                    }
                    /// <summary>
                    /// 当前考试题目编号 计算初始化完毕
                    /// </summary>
                    public static void QuestionIndexLoaded() { sqlStreamCount/**/.Load(26); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class favorite
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.favorite
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.favorite> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.favorite>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.favorite> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.favorite>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.favorite>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 2, 5);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.favorite> _m2 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusCount);
                    /// <summary>
                    /// 关注者数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusCount(int value)
                    {
                        if (!value.Equals(_value_.FocusCount))
                        {
                            _value_.FocusCount = value;
                            FocusCount();
                        }
                    }
                    /// <summary>
                    /// 关注者数量 (更新日志流)
                    /// </summary>
                    public void FocusCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m2);
                    }
                    /// <summary>
                    /// 关注者数量 计算初始化完毕
                    /// </summary>
                    public static void FocusCountLoaded() { sqlStreamCount/**/.Load(2); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.favorite> _m5 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.LinkCount);
                    /// <summary>
                    /// 收藏数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void LinkCount(int value)
                    {
                        if (!value.Equals(_value_.LinkCount))
                        {
                            _value_.LinkCount = value;
                            LinkCount();
                        }
                    }
                    /// <summary>
                    /// 收藏数量 (更新日志流)
                    /// </summary>
                    public void LinkCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m5);
                    }
                    /// <summary>
                    /// 收藏数量 计算初始化完毕
                    /// </summary>
                    public static void LinkCountLoaded() { sqlStreamCount/**/.Load(5); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class favorites
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 收藏夹标识
                /// </summary>
                public int FavoriteId;
                /// <summary>
                /// 收藏目标标识
                /// </summary>
                public int LinkId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return FavoriteId/**/.Equals(other.FavoriteId) && LinkId/**/.Equals(other.LinkId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return FavoriteId.GetHashCode() ^ LinkId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.favorites
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.favorites, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.favorites, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class focus
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关注标识
                /// </summary>
                public int FocusId;
                /// <summary>
                /// 关注状态
                /// </summary>
                public diantou.dataModel.focus.type Type;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && FocusId/**/.Equals(other.FocusId) && Type/**/.Equals(other.Type);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ FocusId/**/.GetHashCode() ^ Type/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.focus
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.focus, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.focus, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class invitationCode
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.invitationCode
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.invitationCode, string> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.invitationCode, string>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class judgeItem
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.judgeItem
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.judgeItem> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.judgeItem>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class judgeState
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.judgeState
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.judgeState> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.judgeState>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class log
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.log
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.log> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.log>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class mail
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.mail
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.mail> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.mail>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class medal
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.medal
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.medal, string> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.medal, string>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.medal> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.medal>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.medal>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class message
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.message
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.message> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.message>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class notice
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.notice
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.notice> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.notice>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class openJudge
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 客户提交标识
                /// </summary>
                public int ClientId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && ClientId/**/.Equals(other.ClientId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ ClientId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.openJudge
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.openJudge, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.openJudge, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class payProduct
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.payProduct
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.payProduct> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.payProduct>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class payProductOrder
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.payProductOrder
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.payProductOrder> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.payProductOrder>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class problem
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.problem
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.problem> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.problem>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.problem> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.problem>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.problem>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 0, 5, 6, 7, 19, 37, 44);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m0 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.AcceptedUserCount);
                    /// <summary>
                    /// 程序测试AC用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void AcceptedUserCount(int value)
                    {
                        if (!value.Equals(_value_.AcceptedUserCount))
                        {
                            _value_.AcceptedUserCount = value;
                            AcceptedUserCount();
                        }
                    }
                    /// <summary>
                    /// 程序测试AC用户数量 (更新日志流)
                    /// </summary>
                    public void AcceptedUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m0);
                    }
                    /// <summary>
                    /// 程序测试AC用户数量 计算初始化完毕
                    /// </summary>
                    public static void AcceptedUserCountLoaded() { sqlStreamCount/**/.Load(0); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m5 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestAcceptedUserCount);
                    /// <summary>
                    /// 比赛测试AC用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestAcceptedUserCount(int value)
                    {
                        if (!value.Equals(_value_.ContestAcceptedUserCount))
                        {
                            _value_.ContestAcceptedUserCount = value;
                            ContestAcceptedUserCount();
                        }
                    }
                    /// <summary>
                    /// 比赛测试AC用户数量 (更新日志流)
                    /// </summary>
                    public void ContestAcceptedUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m5);
                    }
                    /// <summary>
                    /// 比赛测试AC用户数量 计算初始化完毕
                    /// </summary>
                    public static void ContestAcceptedUserCountLoaded() { sqlStreamCount/**/.Load(5); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m6 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestId);
                    /// <summary>
                    /// 比赛标识 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestId(int value)
                    {
                        if (!value.Equals(_value_.ContestId))
                        {
                            _value_.ContestId = value;
                            ContestId();
                        }
                    }
                    /// <summary>
                    /// 比赛标识 (更新日志流)
                    /// </summary>
                    public void ContestId()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m6);
                    }
                    /// <summary>
                    /// 比赛标识 计算初始化完毕
                    /// </summary>
                    public static void ContestIdLoaded() { sqlStreamCount/**/.Load(6); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m7 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestJudgeCount);
                    /// <summary>
                    /// 比赛测试数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestJudgeCount(int value)
                    {
                        if (!value.Equals(_value_.ContestJudgeCount))
                        {
                            _value_.ContestJudgeCount = value;
                            ContestJudgeCount();
                        }
                    }
                    /// <summary>
                    /// 比赛测试数量 (更新日志流)
                    /// </summary>
                    public void ContestJudgeCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m7);
                    }
                    /// <summary>
                    /// 比赛测试数量 计算初始化完毕
                    /// </summary>
                    public static void ContestJudgeCountLoaded() { sqlStreamCount/**/.Load(7); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m19 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.JudgeCount);
                    /// <summary>
                    /// 测试数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void JudgeCount(int value)
                    {
                        if (!value.Equals(_value_.JudgeCount))
                        {
                            _value_.JudgeCount = value;
                            JudgeCount();
                        }
                    }
                    /// <summary>
                    /// 测试数量 (更新日志流)
                    /// </summary>
                    public void JudgeCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m19);
                    }
                    /// <summary>
                    /// 测试数量 计算初始化完毕
                    /// </summary>
                    public static void JudgeCountLoaded() { sqlStreamCount/**/.Load(19); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m37 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.TestDataCount);
                    /// <summary>
                    /// 测试数据数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void TestDataCount(int value)
                    {
                        if (!value.Equals(_value_.TestDataCount))
                        {
                            _value_.TestDataCount = value;
                            TestDataCount();
                        }
                    }
                    /// <summary>
                    /// 测试数据数量 (更新日志流)
                    /// </summary>
                    public void TestDataCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m37);
                    }
                    /// <summary>
                    /// 测试数据数量 计算初始化完毕
                    /// </summary>
                    public static void TestDataCountLoaded() { sqlStreamCount/**/.Load(37); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.problem> _m44 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.TopicCount);
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void TopicCount(int value)
                    {
                        if (!value.Equals(_value_.TopicCount))
                        {
                            _value_.TopicCount = value;
                            TopicCount();
                        }
                    }
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    public void TopicCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m44);
                    }
                    /// <summary>
                    /// 话题数量 计算初始化完毕
                    /// </summary>
                    public static void TopicCountLoaded() { sqlStreamCount/**/.Load(44); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class problemGroup
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.problemGroup
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.problemGroup, string> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.problemGroup, string>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.problemGroup> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.problemGroup>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.problemGroup>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class problemTestData
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 问题标识
                /// </summary>
                public int ProblemId;
                /// <summary>
                /// 测试编号
                /// </summary>
                public int TestId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return ProblemId/**/.Equals(other.ProblemId) && TestId/**/.Equals(other.TestId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return ProblemId.GetHashCode() ^ TestId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.problemTestData
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.problemTestData, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.problemTestData, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class programDraft
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 问题标识
                /// </summary>
                public int ProblemId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && ProblemId/**/.Equals(other.ProblemId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ ProblemId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.programDraft
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.programDraft, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.programDraft, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class question
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.question
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.question> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.question>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.question> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.question>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.question>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 0, 2, 7, 8, 12, 15, 17, 24);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m0 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.AnswerCount);
                    /// <summary>
                    /// 回答数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void AnswerCount(int value)
                    {
                        if (!value.Equals(_value_.AnswerCount))
                        {
                            _value_.AnswerCount = value;
                            AnswerCount();
                        }
                    }
                    /// <summary>
                    /// 回答数量 (更新日志流)
                    /// </summary>
                    public void AnswerCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m0);
                    }
                    /// <summary>
                    /// 回答数量 计算初始化完毕
                    /// </summary>
                    public static void AnswerCountLoaded() { sqlStreamCount/**/.Load(0); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m2 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.BestAnswerId);
                    /// <summary>
                    /// 最佳答案标识 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void BestAnswerId(int value)
                    {
                        if (!value.Equals(_value_.BestAnswerId))
                        {
                            _value_.BestAnswerId = value;
                            BestAnswerId();
                        }
                    }
                    /// <summary>
                    /// 最佳答案标识 (更新日志流)
                    /// </summary>
                    public void BestAnswerId()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m2);
                    }
                    /// <summary>
                    /// 最佳答案标识 计算初始化完毕
                    /// </summary>
                    public static void BestAnswerIdLoaded() { sqlStreamCount/**/.Load(2); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m7 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FavoriteCount);
                    /// <summary>
                    /// 收藏次数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FavoriteCount(int value)
                    {
                        if (!value.Equals(_value_.FavoriteCount))
                        {
                            _value_.FavoriteCount = value;
                            FavoriteCount();
                        }
                    }
                    /// <summary>
                    /// 收藏次数 (更新日志流)
                    /// </summary>
                    public void FavoriteCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m7);
                    }
                    /// <summary>
                    /// 收藏次数 计算初始化完毕
                    /// </summary>
                    public static void FavoriteCountLoaded() { sqlStreamCount/**/.Load(7); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m8 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusCount);
                    /// <summary>
                    /// 关注者数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusCount(int value)
                    {
                        if (!value.Equals(_value_.FocusCount))
                        {
                            _value_.FocusCount = value;
                            FocusCount();
                        }
                    }
                    /// <summary>
                    /// 关注者数量 (更新日志流)
                    /// </summary>
                    public void FocusCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m8);
                    }
                    /// <summary>
                    /// 关注者数量 计算初始化完毕
                    /// </summary>
                    public static void FocusCountLoaded() { sqlStreamCount/**/.Load(8); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m12 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.LastAnswerId);
                    /// <summary>
                    /// 最后答案标识 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void LastAnswerId(int value)
                    {
                        if (!value.Equals(_value_.LastAnswerId))
                        {
                            _value_.LastAnswerId = value;
                            LastAnswerId();
                        }
                    }
                    /// <summary>
                    /// 最后答案标识 (更新日志流)
                    /// </summary>
                    public void LastAnswerId()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m12);
                    }
                    /// <summary>
                    /// 最后答案标识 计算初始化完毕
                    /// </summary>
                    public static void LastAnswerIdLoaded() { sqlStreamCount/**/.Load(12); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m15 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.LinkCount);
                    /// <summary>
                    /// 重定向问题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void LinkCount(int value)
                    {
                        if (!value.Equals(_value_.LinkCount))
                        {
                            _value_.LinkCount = value;
                            LinkCount();
                        }
                    }
                    /// <summary>
                    /// 重定向问题数量 (更新日志流)
                    /// </summary>
                    public void LinkCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m15);
                    }
                    /// <summary>
                    /// 重定向问题数量 计算初始化完毕
                    /// </summary>
                    public static void LinkCountLoaded() { sqlStreamCount/**/.Load(15); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m17 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ProblemId);
                    /// <summary>
                    /// OJ问题标识 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ProblemId(int value)
                    {
                        if (!value.Equals(_value_.ProblemId))
                        {
                            _value_.ProblemId = value;
                            ProblemId();
                        }
                    }
                    /// <summary>
                    /// OJ问题标识 (更新日志流)
                    /// </summary>
                    public void ProblemId()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m17);
                    }
                    /// <summary>
                    /// OJ问题标识 计算初始化完毕
                    /// </summary>
                    public static void ProblemIdLoaded() { sqlStreamCount/**/.Load(17); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.question> _m24 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.TopicCount);
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void TopicCount(int value)
                    {
                        if (!value.Equals(_value_.TopicCount))
                        {
                            _value_.TopicCount = value;
                            TopicCount();
                        }
                    }
                    /// <summary>
                    /// 话题数量 (更新日志流)
                    /// </summary>
                    public void TopicCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m24);
                    }
                    /// <summary>
                    /// 话题数量 计算初始化完毕
                    /// </summary>
                    public static void TopicCountLoaded() { sqlStreamCount/**/.Load(24); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class questionDraft
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.questionDraft
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.questionDraft, int> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.questionDraft, int>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class questionInvite
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 问题标识
                /// </summary>
                public int QuestionId;
                /// <summary>
                /// 被邀请用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return QuestionId/**/.Equals(other.QuestionId) && UserId/**/.Equals(other.UserId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return QuestionId.GetHashCode() ^ UserId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.questionInvite
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.questionInvite, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.questionInvite, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class report
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 被举报标识
                /// </summary>
                public int ReportId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && ReportId/**/.Equals(other.ReportId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ ReportId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.report
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.report, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.report, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class testDataPoint
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户id
                /// </summary>
                public int UserId;
                /// <summary>
                /// 问题标识
                /// </summary>
                public int ProblemId;
                /// <summary>
                /// 测试编号
                /// </summary>
                public int TestId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && ProblemId/**/.Equals(other.ProblemId) && TestId/**/.Equals(other.TestId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ ProblemId/**/.GetHashCode() ^ TestId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.testDataPoint
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.testDataPoint, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.testDataPoint, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class topic
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.topic
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.topic> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.topic>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class topics
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 话题标识
                /// </summary>
                public int TopicId;
                /// <summary>
                /// 关联标识
                /// </summary>
                public int LinkId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return TopicId/**/.Equals(other.TopicId) && LinkId/**/.Equals(other.LinkId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return TopicId.GetHashCode() ^ LinkId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.topics
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.topics, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.topics, primaryKey>.Get();
            }
        }
}namespace diantou.dataModel
{
        public partial class tutorial
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.tutorial
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.tutorial> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.tutorial>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.tutorial> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.tutorial>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.tutorial>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 2, 3, 7, 14);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.tutorial> _m2 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.CourseCount);
                    /// <summary>
                    /// 课程数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void CourseCount(int value)
                    {
                        if (!value.Equals(_value_.CourseCount))
                        {
                            _value_.CourseCount = value;
                            CourseCount();
                        }
                    }
                    /// <summary>
                    /// 课程数量 (更新日志流)
                    /// </summary>
                    public void CourseCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m2);
                    }
                    /// <summary>
                    /// 课程数量 计算初始化完毕
                    /// </summary>
                    public static void CourseCountLoaded() { sqlStreamCount/**/.Load(2); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.tutorial> _m3 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.CoursePageCount);
                    /// <summary>
                    /// 课程分页数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void CoursePageCount(int value)
                    {
                        if (!value.Equals(_value_.CoursePageCount))
                        {
                            _value_.CoursePageCount = value;
                            CoursePageCount();
                        }
                    }
                    /// <summary>
                    /// 课程分页数量 (更新日志流)
                    /// </summary>
                    public void CoursePageCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m3);
                    }
                    /// <summary>
                    /// 课程分页数量 计算初始化完毕
                    /// </summary>
                    public static void CoursePageCountLoaded() { sqlStreamCount/**/.Load(3); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.tutorial> _m7 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.PassUserCount);
                    /// <summary>
                    /// 通过用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void PassUserCount(int value)
                    {
                        if (!value.Equals(_value_.PassUserCount))
                        {
                            _value_.PassUserCount = value;
                            PassUserCount();
                        }
                    }
                    /// <summary>
                    /// 通过用户数量 (更新日志流)
                    /// </summary>
                    public void PassUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m7);
                    }
                    /// <summary>
                    /// 通过用户数量 计算初始化完毕
                    /// </summary>
                    public static void PassUserCountLoaded() { sqlStreamCount/**/.Load(7); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.tutorial> _m14 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UserCount);
                    /// <summary>
                    /// 参与用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UserCount(int value)
                    {
                        if (!value.Equals(_value_.UserCount))
                        {
                            _value_.UserCount = value;
                            UserCount();
                        }
                    }
                    /// <summary>
                    /// 参与用户数量 (更新日志流)
                    /// </summary>
                    public void UserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m14);
                    }
                    /// <summary>
                    /// 参与用户数量 计算初始化完毕
                    /// </summary>
                    public static void UserCountLoaded() { sqlStreamCount/**/.Load(14); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class user
        {

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.user
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.user, string> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.user, string>.Get();
                /// <summary>
                /// 日志
                /// </summary>
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.user> sqlStream;
                /// <summary>
                /// 获取日志流缓存数据
                /// </summary>
                /// <returns>日志流缓存数据</returns>
                [fastCSharp.code.cSharp.tcpMethod(IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, Service = "DataLog")]
                protected static fastCSharp.sql.logStream<valueType, diantou.dataModel.user>.cacheIdentity getSqlCache()
                {
                    return sqlStream/**/.Cache;
                }
                /// <summary>
                /// 日志处理
                /// </summary>
                /// <param name="ticks">时钟周期标识</param>
                /// <param name="identity">日志编号</param>
                /// <param name="onLog"></param>
                [fastCSharp.code.cSharp.tcpMethod(IsServerAsynchronousCallback = true, IsClientCallbackTask = false, IsClientAsynchronous = true, IsClientSynchronous = false, IsKeepCallback = true, Service = "DataLog")]
                protected static void onSqlLog(long ticks, int identity, Func<fastCSharp.net.returnValue<fastCSharp.sql.logStream<valueType, diantou.dataModel.user>.data>, bool> onLog)
                {
                    sqlStream/**/.OnLog(ticks, identity, onLog);
                }
                /// <summary>
                /// 成员加载计数器
                /// </summary>
                protected static readonly fastCSharp.sql.logStream.memberCount sqlStreamCount = new fastCSharp.sql.logStream.memberCount(-1, 1, 7, 8, 9, 10, 11, 13, 14, 27, 29, 31, 32, 34, 35, 36, 37, 38, 44, 58, 60, 65, 66, 67, 68, 69, 70, 77, 79, 83, 93, 96, 97);
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                public struct sqlStreamLoad
                {
                    /// <summary>
                    /// 数据对象
                    /// </summary>
                    internal sqlModel<valueType> _value_;
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m1 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.AnswerCount);
                    /// <summary>
                    /// 我的回答数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void AnswerCount(int value)
                    {
                        if (!value.Equals(_value_.AnswerCount))
                        {
                            _value_.AnswerCount = value;
                            AnswerCount();
                        }
                    }
                    /// <summary>
                    /// 我的回答数量 (更新日志流)
                    /// </summary>
                    public void AnswerCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m1);
                    }
                    /// <summary>
                    /// 我的回答数量 计算初始化完毕
                    /// </summary>
                    public static void AnswerCountLoaded() { sqlStreamCount/**/.Load(1); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m7 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestBronzeCount);
                    /// <summary>
                    /// 比赛铜牌数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestBronzeCount(int value)
                    {
                        if (!value.Equals(_value_.ContestBronzeCount))
                        {
                            _value_.ContestBronzeCount = value;
                            ContestBronzeCount();
                        }
                    }
                    /// <summary>
                    /// 比赛铜牌数量 (更新日志流)
                    /// </summary>
                    public void ContestBronzeCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m7);
                    }
                    /// <summary>
                    /// 比赛铜牌数量 计算初始化完毕
                    /// </summary>
                    public static void ContestBronzeCountLoaded() { sqlStreamCount/**/.Load(7); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m8 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestCount);
                    /// <summary>
                    /// 注册比赛数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestCount(int value)
                    {
                        if (!value.Equals(_value_.ContestCount))
                        {
                            _value_.ContestCount = value;
                            ContestCount();
                        }
                    }
                    /// <summary>
                    /// 注册比赛数量 (更新日志流)
                    /// </summary>
                    public void ContestCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m8);
                    }
                    /// <summary>
                    /// 注册比赛数量 计算初始化完毕
                    /// </summary>
                    public static void ContestCountLoaded() { sqlStreamCount/**/.Load(8); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m9 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestGoldCount);
                    /// <summary>
                    /// 比赛金牌数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestGoldCount(int value)
                    {
                        if (!value.Equals(_value_.ContestGoldCount))
                        {
                            _value_.ContestGoldCount = value;
                            ContestGoldCount();
                        }
                    }
                    /// <summary>
                    /// 比赛金牌数量 (更新日志流)
                    /// </summary>
                    public void ContestGoldCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m9);
                    }
                    /// <summary>
                    /// 比赛金牌数量 计算初始化完毕
                    /// </summary>
                    public static void ContestGoldCountLoaded() { sqlStreamCount/**/.Load(9); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m10 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestRank);
                    /// <summary>
                    /// 比赛排行 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestRank(int value)
                    {
                        if (!value.Equals(_value_.ContestRank))
                        {
                            _value_.ContestRank = value;
                            ContestRank();
                        }
                    }
                    /// <summary>
                    /// 比赛排行 (更新日志流)
                    /// </summary>
                    public void ContestRank()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m10);
                    }
                    /// <summary>
                    /// 比赛排行 计算初始化完毕
                    /// </summary>
                    public static void ContestRankLoaded() { sqlStreamCount/**/.Load(10); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m11 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestRating);
                    /// <summary>
                    /// 比赛得分等级 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestRating(int value)
                    {
                        if (!value.Equals(_value_.ContestRating))
                        {
                            _value_.ContestRating = value;
                            ContestRating();
                        }
                    }
                    /// <summary>
                    /// 比赛得分等级 (更新日志流)
                    /// </summary>
                    public void ContestRating()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m11);
                    }
                    /// <summary>
                    /// 比赛得分等级 计算初始化完毕
                    /// </summary>
                    public static void ContestRatingLoaded() { sqlStreamCount/**/.Load(11); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m13 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestSilverCount);
                    /// <summary>
                    /// 比赛银牌数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestSilverCount(int value)
                    {
                        if (!value.Equals(_value_.ContestSilverCount))
                        {
                            _value_.ContestSilverCount = value;
                            ContestSilverCount();
                        }
                    }
                    /// <summary>
                    /// 比赛银牌数量 (更新日志流)
                    /// </summary>
                    public void ContestSilverCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m13);
                    }
                    /// <summary>
                    /// 比赛银牌数量 计算初始化完毕
                    /// </summary>
                    public static void ContestSilverCountLoaded() { sqlStreamCount/**/.Load(13); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m14 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ContestSubmitCount);
                    /// <summary>
                    /// 用户比赛提交次数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ContestSubmitCount(int value)
                    {
                        if (!value.Equals(_value_.ContestSubmitCount))
                        {
                            _value_.ContestSubmitCount = value;
                            ContestSubmitCount();
                        }
                    }
                    /// <summary>
                    /// 用户比赛提交次数 (更新日志流)
                    /// </summary>
                    public void ContestSubmitCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m14);
                    }
                    /// <summary>
                    /// 用户比赛提交次数 计算初始化完毕
                    /// </summary>
                    public static void ContestSubmitCountLoaded() { sqlStreamCount/**/.Load(14); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m27 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ExternalContestCount);
                    /// <summary>
                    /// 发布的外部比赛数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ExternalContestCount(int value)
                    {
                        if (!value.Equals(_value_.ExternalContestCount))
                        {
                            _value_.ExternalContestCount = value;
                            ExternalContestCount();
                        }
                    }
                    /// <summary>
                    /// 发布的外部比赛数量 (更新日志流)
                    /// </summary>
                    public void ExternalContestCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m27);
                    }
                    /// <summary>
                    /// 发布的外部比赛数量 计算初始化完毕
                    /// </summary>
                    public static void ExternalContestCountLoaded() { sqlStreamCount/**/.Load(27); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m29 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FavoritesCount);
                    /// <summary>
                    /// 我的收藏夹数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FavoritesCount(int value)
                    {
                        if (!value.Equals(_value_.FavoritesCount))
                        {
                            _value_.FavoritesCount = value;
                            FavoritesCount();
                        }
                    }
                    /// <summary>
                    /// 我的收藏夹数量 (更新日志流)
                    /// </summary>
                    public void FavoritesCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m29);
                    }
                    /// <summary>
                    /// 我的收藏夹数量 计算初始化完毕
                    /// </summary>
                    public static void FavoritesCountLoaded() { sqlStreamCount/**/.Load(29); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m31 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusCount);
                    /// <summary>
                    /// 关注我的用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusCount(int value)
                    {
                        if (!value.Equals(_value_.FocusCount))
                        {
                            _value_.FocusCount = value;
                            FocusCount();
                        }
                    }
                    /// <summary>
                    /// 关注我的用户数量 (更新日志流)
                    /// </summary>
                    public void FocusCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m31);
                    }
                    /// <summary>
                    /// 关注我的用户数量 计算初始化完毕
                    /// </summary>
                    public static void FocusCountLoaded() { sqlStreamCount/**/.Load(31); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m32 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusFavoriteCount);
                    /// <summary>
                    /// 我关注的收藏夹数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusFavoriteCount(int value)
                    {
                        if (!value.Equals(_value_.FocusFavoriteCount))
                        {
                            _value_.FocusFavoriteCount = value;
                            FocusFavoriteCount();
                        }
                    }
                    /// <summary>
                    /// 我关注的收藏夹数量 (更新日志流)
                    /// </summary>
                    public void FocusFavoriteCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m32);
                    }
                    /// <summary>
                    /// 我关注的收藏夹数量 计算初始化完毕
                    /// </summary>
                    public static void FocusFavoriteCountLoaded() { sqlStreamCount/**/.Load(32); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m34 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusProblemCount);
                    /// <summary>
                    /// 关注题目数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusProblemCount(int value)
                    {
                        if (!value.Equals(_value_.FocusProblemCount))
                        {
                            _value_.FocusProblemCount = value;
                            FocusProblemCount();
                        }
                    }
                    /// <summary>
                    /// 关注题目数量 (更新日志流)
                    /// </summary>
                    public void FocusProblemCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m34);
                    }
                    /// <summary>
                    /// 关注题目数量 计算初始化完毕
                    /// </summary>
                    public static void FocusProblemCountLoaded() { sqlStreamCount/**/.Load(34); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m35 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusQuestionCount);
                    /// <summary>
                    /// 关注问题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusQuestionCount(int value)
                    {
                        if (!value.Equals(_value_.FocusQuestionCount))
                        {
                            _value_.FocusQuestionCount = value;
                            FocusQuestionCount();
                        }
                    }
                    /// <summary>
                    /// 关注问题数量 (更新日志流)
                    /// </summary>
                    public void FocusQuestionCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m35);
                    }
                    /// <summary>
                    /// 关注问题数量 计算初始化完毕
                    /// </summary>
                    public static void FocusQuestionCountLoaded() { sqlStreamCount/**/.Load(35); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m36 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusTopicCount);
                    /// <summary>
                    /// 关注话题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusTopicCount(int value)
                    {
                        if (!value.Equals(_value_.FocusTopicCount))
                        {
                            _value_.FocusTopicCount = value;
                            FocusTopicCount();
                        }
                    }
                    /// <summary>
                    /// 关注话题数量 (更新日志流)
                    /// </summary>
                    public void FocusTopicCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m36);
                    }
                    /// <summary>
                    /// 关注话题数量 计算初始化完毕
                    /// </summary>
                    public static void FocusTopicCountLoaded() { sqlStreamCount/**/.Load(36); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m37 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FocusUserCount);
                    /// <summary>
                    /// 我关注的用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FocusUserCount(int value)
                    {
                        if (!value.Equals(_value_.FocusUserCount))
                        {
                            _value_.FocusUserCount = value;
                            FocusUserCount();
                        }
                    }
                    /// <summary>
                    /// 我关注的用户数量 (更新日志流)
                    /// </summary>
                    public void FocusUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m37);
                    }
                    /// <summary>
                    /// 我关注的用户数量 计算初始化完毕
                    /// </summary>
                    public static void FocusUserCountLoaded() { sqlStreamCount/**/.Load(37); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m38 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.FriendCount);
                    /// <summary>
                    /// 好友数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void FriendCount(int value)
                    {
                        if (!value.Equals(_value_.FriendCount))
                        {
                            _value_.FriendCount = value;
                            FriendCount();
                        }
                    }
                    /// <summary>
                    /// 好友数量 (更新日志流)
                    /// </summary>
                    public void FriendCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m38);
                    }
                    /// <summary>
                    /// 好友数量 计算初始化完毕
                    /// </summary>
                    public static void FriendCountLoaded() { sqlStreamCount/**/.Load(38); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m44 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.IdolCount);
                    /// <summary>
                    /// 我的偶像数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void IdolCount(int value)
                    {
                        if (!value.Equals(_value_.IdolCount))
                        {
                            _value_.IdolCount = value;
                            IdolCount();
                        }
                    }
                    /// <summary>
                    /// 我的偶像数量 (更新日志流)
                    /// </summary>
                    public void IdolCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m44);
                    }
                    /// <summary>
                    /// 我的偶像数量 计算初始化完毕
                    /// </summary>
                    public static void IdolCountLoaded() { sqlStreamCount/**/.Load(44); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m58 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.MentionNewCount);
                    /// <summary>
                    /// @提到我的更新数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void MentionNewCount(int value)
                    {
                        if (!value.Equals(_value_.MentionNewCount))
                        {
                            _value_.MentionNewCount = value;
                            MentionNewCount();
                        }
                    }
                    /// <summary>
                    /// @提到我的更新数量 (更新日志流)
                    /// </summary>
                    public void MentionNewCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m58);
                    }
                    /// <summary>
                    /// @提到我的更新数量 计算初始化完毕
                    /// </summary>
                    public static void MentionNewCountLoaded() { sqlStreamCount/**/.Load(58); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m60 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.MessageNewUserCount);
                    /// <summary>
                    /// 新的私信用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void MessageNewUserCount(int value)
                    {
                        if (!value.Equals(_value_.MessageNewUserCount))
                        {
                            _value_.MessageNewUserCount = value;
                            MessageNewUserCount();
                        }
                    }
                    /// <summary>
                    /// 新的私信用户数量 (更新日志流)
                    /// </summary>
                    public void MessageNewUserCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m60);
                    }
                    /// <summary>
                    /// 新的私信用户数量 计算初始化完毕
                    /// </summary>
                    public static void MessageNewUserCountLoaded() { sqlStreamCount/**/.Load(60); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m65 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.OnlineJudgeAcceptedPoint);
                    /// <summary>
                    /// AC问题分数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void OnlineJudgeAcceptedPoint(int value)
                    {
                        if (!value.Equals(_value_.OnlineJudgeAcceptedPoint))
                        {
                            _value_.OnlineJudgeAcceptedPoint = value;
                            OnlineJudgeAcceptedPoint();
                        }
                    }
                    /// <summary>
                    /// AC问题分数 (更新日志流)
                    /// </summary>
                    public void OnlineJudgeAcceptedPoint()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m65);
                    }
                    /// <summary>
                    /// AC问题分数 计算初始化完毕
                    /// </summary>
                    public static void OnlineJudgeAcceptedPointLoaded() { sqlStreamCount/**/.Load(65); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m66 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.OnlineJudgeAcceptedProblemCount);
                    /// <summary>
                    /// 用户在线测试通过问题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void OnlineJudgeAcceptedProblemCount(int value)
                    {
                        if (!value.Equals(_value_.OnlineJudgeAcceptedProblemCount))
                        {
                            _value_.OnlineJudgeAcceptedProblemCount = value;
                            OnlineJudgeAcceptedProblemCount();
                        }
                    }
                    /// <summary>
                    /// 用户在线测试通过问题数量 (更新日志流)
                    /// </summary>
                    public void OnlineJudgeAcceptedProblemCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m66);
                    }
                    /// <summary>
                    /// 用户在线测试通过问题数量 计算初始化完毕
                    /// </summary>
                    public static void OnlineJudgeAcceptedProblemCountLoaded() { sqlStreamCount/**/.Load(66); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m67 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.OnlineJudgeBronzeCount);
                    /// <summary>
                    /// 铜牌数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void OnlineJudgeBronzeCount(int value)
                    {
                        if (!value.Equals(_value_.OnlineJudgeBronzeCount))
                        {
                            _value_.OnlineJudgeBronzeCount = value;
                            OnlineJudgeBronzeCount();
                        }
                    }
                    /// <summary>
                    /// 铜牌数量 (更新日志流)
                    /// </summary>
                    public void OnlineJudgeBronzeCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m67);
                    }
                    /// <summary>
                    /// 铜牌数量 计算初始化完毕
                    /// </summary>
                    public static void OnlineJudgeBronzeCountLoaded() { sqlStreamCount/**/.Load(67); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m68 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.OnlineJudgeGoldCount);
                    /// <summary>
                    /// 金牌数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void OnlineJudgeGoldCount(int value)
                    {
                        if (!value.Equals(_value_.OnlineJudgeGoldCount))
                        {
                            _value_.OnlineJudgeGoldCount = value;
                            OnlineJudgeGoldCount();
                        }
                    }
                    /// <summary>
                    /// 金牌数量 (更新日志流)
                    /// </summary>
                    public void OnlineJudgeGoldCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m68);
                    }
                    /// <summary>
                    /// 金牌数量 计算初始化完毕
                    /// </summary>
                    public static void OnlineJudgeGoldCountLoaded() { sqlStreamCount/**/.Load(68); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m69 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.OnlineJudgeSilverCount);
                    /// <summary>
                    /// 银牌数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void OnlineJudgeSilverCount(int value)
                    {
                        if (!value.Equals(_value_.OnlineJudgeSilverCount))
                        {
                            _value_.OnlineJudgeSilverCount = value;
                            OnlineJudgeSilverCount();
                        }
                    }
                    /// <summary>
                    /// 银牌数量 (更新日志流)
                    /// </summary>
                    public void OnlineJudgeSilverCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m69);
                    }
                    /// <summary>
                    /// 银牌数量 计算初始化完毕
                    /// </summary>
                    public static void OnlineJudgeSilverCountLoaded() { sqlStreamCount/**/.Load(69); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m70 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.OnlineJudgeSubmitCount);
                    /// <summary>
                    /// 用户在线测试提交次数 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void OnlineJudgeSubmitCount(int value)
                    {
                        if (!value.Equals(_value_.OnlineJudgeSubmitCount))
                        {
                            _value_.OnlineJudgeSubmitCount = value;
                            OnlineJudgeSubmitCount();
                        }
                    }
                    /// <summary>
                    /// 用户在线测试提交次数 (更新日志流)
                    /// </summary>
                    public void OnlineJudgeSubmitCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m70);
                    }
                    /// <summary>
                    /// 用户在线测试提交次数 计算初始化完毕
                    /// </summary>
                    public static void OnlineJudgeSubmitCountLoaded() { sqlStreamCount/**/.Load(70); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m77 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.QuestionCount);
                    /// <summary>
                    /// 我的问题数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void QuestionCount(int value)
                    {
                        if (!value.Equals(_value_.QuestionCount))
                        {
                            _value_.QuestionCount = value;
                            QuestionCount();
                        }
                    }
                    /// <summary>
                    /// 我的问题数量 (更新日志流)
                    /// </summary>
                    public void QuestionCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m77);
                    }
                    /// <summary>
                    /// 我的问题数量 计算初始化完毕
                    /// </summary>
                    public static void QuestionCountLoaded() { sqlStreamCount/**/.Load(77); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m79 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ReceiveAgreeCount);
                    /// <summary>
                    /// 赞成我的数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ReceiveAgreeCount(int value)
                    {
                        if (!value.Equals(_value_.ReceiveAgreeCount))
                        {
                            _value_.ReceiveAgreeCount = value;
                            ReceiveAgreeCount();
                        }
                    }
                    /// <summary>
                    /// 赞成我的数量 (更新日志流)
                    /// </summary>
                    public void ReceiveAgreeCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m79);
                    }
                    /// <summary>
                    /// 赞成我的数量 计算初始化完毕
                    /// </summary>
                    public static void ReceiveAgreeCountLoaded() { sqlStreamCount/**/.Load(79); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m83 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.ReceiveThankCount);
                    /// <summary>
                    /// 收到感谢的数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void ReceiveThankCount(int value)
                    {
                        if (!value.Equals(_value_.ReceiveThankCount))
                        {
                            _value_.ReceiveThankCount = value;
                            ReceiveThankCount();
                        }
                    }
                    /// <summary>
                    /// 收到感谢的数量 (更新日志流)
                    /// </summary>
                    public void ReceiveThankCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m83);
                    }
                    /// <summary>
                    /// 收到感谢的数量 计算初始化完毕
                    /// </summary>
                    public static void ReceiveThankCountLoaded() { sqlStreamCount/**/.Load(83); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m93 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.TutorialCount);
                    /// <summary>
                    /// 参与课程数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void TutorialCount(int value)
                    {
                        if (!value.Equals(_value_.TutorialCount))
                        {
                            _value_.TutorialCount = value;
                            TutorialCount();
                        }
                    }
                    /// <summary>
                    /// 参与课程数量 (更新日志流)
                    /// </summary>
                    public void TutorialCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m93);
                    }
                    /// <summary>
                    /// 参与课程数量 计算初始化完毕
                    /// </summary>
                    public static void TutorialCountLoaded() { sqlStreamCount/**/.Load(93); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m96 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UserFriendCount);
                    /// <summary>
                    /// 设我为好友的用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UserFriendCount(int value)
                    {
                        if (!value.Equals(_value_.UserFriendCount))
                        {
                            _value_.UserFriendCount = value;
                            UserFriendCount();
                        }
                    }
                    /// <summary>
                    /// 设我为好友的用户数量 (更新日志流)
                    /// </summary>
                    public void UserFriendCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m96);
                    }
                    /// <summary>
                    /// 设我为好友的用户数量 计算初始化完毕
                    /// </summary>
                    public static void UserFriendCountLoaded() { sqlStreamCount/**/.Load(96); }
                    private static readonly fastCSharp.code.memberMap<diantou.dataModel.user> _m97 = fastCSharp.sql.logStream.CreateMemberMap(sqlTable, value => value.UserIdolCount);
                    /// <summary>
                    /// 设我为偶像的用户数量 (更新日志流)
                    /// </summary>
                    /// <param name="value"></param>
                    public void UserIdolCount(int value)
                    {
                        if (!value.Equals(_value_.UserIdolCount))
                        {
                            _value_.UserIdolCount = value;
                            UserIdolCount();
                        }
                    }
                    /// <summary>
                    /// 设我为偶像的用户数量 (更新日志流)
                    /// </summary>
                    public void UserIdolCount()
                    {
                        if (sqlStream != null) sqlStream/**/.Update((valueType)_value_, _m97);
                    }
                    /// <summary>
                    /// 设我为偶像的用户数量 计算初始化完毕
                    /// </summary>
                    public static void UserIdolCountLoaded() { sqlStreamCount/**/.Load(97); }
                }
                /// <summary>
                /// 计算字段日志流
                /// </summary>
                [fastCSharp.code.ignore]
                public sqlStreamLoad SqlStreamLoad
                {
                    get { return new sqlStreamLoad { _value_ = this }; }
                }
            }
        }
}namespace diantou.dataModel
{
        public partial class userCourse
        {
            /// <summary>
            /// 关键字
            /// </summary>
            [fastCSharp.code.ignore]
            public struct primaryKey : IEquatable<primaryKey>
            {
                /// <summary>
                /// 用户标识
                /// </summary>
                public int UserId;
                /// <summary>
                /// 课程标识
                /// </summary>
                public int CourseId;
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="other">关键字</param>
                /// <returns>是否相等</returns>
                public bool Equals(primaryKey other)
                {
                    return UserId/**/.Equals(other.UserId) && CourseId/**/.Equals(other.CourseId);
                }
                /// <summary>
                /// 哈希编码
                /// </summary>
                /// <returns></returns>
                public override int GetHashCode()
                {
                    return UserId.GetHashCode() ^ CourseId/**/.GetHashCode();
                }
                /// <summary>
                /// 关键字比较
                /// </summary>
                /// <param name="obj"></param>
                /// <returns></returns>
                public override bool Equals(object obj)
                {
                    return Equals((primaryKey)obj);
                }
            }

            /// <summary>
            /// 数据库表格模型
            /// </summary>
            /// <typeparam name="valueType">表格映射类型</typeparam>
            public abstract class sqlModel<valueType> : diantou.dataModel.userCourse
                where valueType : sqlModel<valueType>
            {
                /// <summary>
                /// SQL表格操作工具
                /// </summary>
                protected static readonly fastCSharp.emit.sqlTable<valueType, diantou.dataModel.userCourse, primaryKey> sqlTable = fastCSharp.emit.sqlTable<valueType, diantou.dataModel.userCourse, primaryKey>.Get();
            }
        }
}
#endif